//shinn:  last_publish To Tool DEV 2013.12.27 19:22 
;
(function() {
	// file: lib/scripts/require.js
	var require,
		define;
	(function() {
		var modules = {},
		// Stack of moduleIds currently being built.
		requireStack = [],
		// Map of module ID -> index into requireStack of modules currently being built.
		inProgressModules = {},
		SEPERATOR = ".";


	    function build(module)
        {
        var factory = module.factory,
            localRequire = function (id) {
                var resultantId = id;
                //Its a relative path, so lop off the last portion and add the id (minus "./")
                if (id.charAt(0) === ".") {
                    resultantId = module.id.slice(0, module.id.lastIndexOf(SEPERATOR)) + SEPERATOR + id.slice(2);
                }
                return require(resultantId);
            };
        module.exports = {};
        delete module.factory;
        factory(localRequire, module.exports, module);
        return module.exports;
        }
     
        require = function(id) {
//     alert("require define " + id);
            if (!modules[id]) {
                throw "module " + id + " not found";
            } else if (id in inProgressModules) {
                var cycle = requireStack.slice(inProgressModules[id]).join('->') + '->' + id;
                throw "Cycle in require graph: " + cycle;
            }
            if (modules[id].factory) {
                try {
                    inProgressModules[id] = requireStack.length;
                    requireStack.push(id);
                    return build(modules[id]);
                } finally {
                    delete inProgressModules[id];
                    requireStack.pop();
                }
            }
            return modules[id].exports;
        };

        define = function(id, factory) {
            if (modules[id]) {
                throw "module " + id + " already defined";
            }

            modules[id] = {
                id: id,
                factory: factory
            };
        };

        define.remove = function(id) {
            delete modules[id];
        };

        define.moduleMap = modules;
    })();
    // end of anonymous method 1

	//Export for use in node
	if (typeof module === "object" && typeof require === "function") {
		module.exports.require = require;
		module.exports.define = define;
	}

	// file: lib/x1bridge.js
	define("x1bridge", function(require, exports, module) {
           
		var channel = require('x1bridge/channel');
           
		/**
		 * Listen for DOMContentLoaded and notify our channel subscribers.
		 */
		document.addEventListener('DOMContentLoaded', function() {
			channel.onDOMContentLoaded.fire();
		}, false);
		if (document.readyState == 'complete' || document.readyState == 'interactive') {
			channel.onDOMContentLoaded.fire();
		}

		if (typeof window.console === "undefined") {
			window.console = {
				log: function() {}
			};
		}

		var x1bridge = {
			define: define,
			require: require,


			/**
			 * Plugin callback mechanism.
			 */
			// Randomize the starting callbackId to avoid collisions after refreshing or navigating.
			// This way, it's very unlikely that any new callback would get the same callbackId as an old callback.
			callbackId: Math.floor(Math.random() * 2000000000),
			callbacks: {},
			callbackStatus: {
				NO_RESULT: 0,
				OK: 1,
				CLASS_NOT_FOUND_EXCEPTION: 2,
				ILLEGAL_ACCESS_EXCEPTION: 3,
				INSTANTIATION_EXCEPTION: 4,
				MALFORMED_URL_EXCEPTION: 5,
				IO_EXCEPTION: 6,
				INVALID_ACTION: 7,
				JSON_EXCEPTION: 8,
				ERROR: 9
			},

			/**
			 * Called by native code when returning successful result from an action.
			 */
			callbackSuccess: function(callbackId, args) {
				try {
           alert("success" + callbackId+args);
					x1bridge.callbackFromNative(callbackId, true, args.status, [args.message], args.keepCallback);
				} catch (e) {
					console.log("Error in error callback: " + callbackId + " = " + e);
				}
			},

			/**
			 * Called by native code when returning error result from an action.
			 */
			callbackError: function(callbackId, args) {
           alert("error" + callbackId+args);
				// TODO: Deprecate callbackSuccess and callbackError in favour of callbackFromNative.
				// Derive success from status.
				try {
					x1bridge.callbackFromNative(callbackId, false, args.status, [args.message], args.keepCallback);
				} catch (e) {
					console.log("Error in error callback: " + callbackId + " = " + e);
				}
			},

			/**
			 * Called by native code when returning the result from an action.
			 */
			callbackFromNative: function(callbackId, success, status, args, keepCallback) {
				var callback = x1bridge.callbacks[callbackId];
				if (callback) {
					if (success && status == 0) {
						callback.success && callback.success.apply(null, args);
					} else if (!success) {
						callback.fail && callback.fail.apply(null, args);
					}

					// Clear callback if not expecting any more results
					if (!keepCallback) {
						delete x1bridge.callbacks[callbackId];
					}
				}
			},
			addConstructor: function(func) {
				channel.onX1bridgeReady.subscribe(function() {
					try {
						func();
					} catch (e) {
						console.log("Failed to run constructor: " + e);
					}
				});
			}
		};
           // TODO 这段不对
		// Register pause, resume and deviceready channels as events on document.
//		channel.onPause = x1bridge.addDocumentEventHandler('pause');
//		channel.onResume = x1bridge.addDocumentEventHandler('resume');
//		channel.onDeviceReady = x1bridge.addStickyDocumentEventHandler('deviceready');
		module.exports = x1bridge;

	});

 // file: lib/common/builder.js
 define("x1bridge/builder", function(require, exports, module) {
        
        var utils = require('x1bridge/utils');
        
        function each(objects, func, context) {
        for (var prop in objects) {
        if (objects.hasOwnProperty(prop)) {
        func.apply(context, [objects[prop], prop]);
        }
        }
        }
        
        function clobber(obj, key, value) {
        exports.replaceHookForTesting(obj, key);
        obj[key] = value;
        // Getters can only be overridden by getters.
        if (obj[key] !== value) {
        utils.defineGetter(obj, key, function() {
                           return value;
                           });
        }
        }
        
        function assignOrWrapInDeprecateGetter(obj, key, value, message) {
        if (message) {
        utils.defineGetter(obj, key, function() {
                           console.log(message);
                           delete obj[key];
                           clobber(obj, key, value);
                           return value;
                           });
        } else {
        clobber(obj, key, value);
        }
        }
        
        function include(parent, objects, clobber, merge) {
        each(objects, function (obj, key) {
             try {
             var result = obj.path ? require(obj.path) : {};
             
             if (clobber) {
             // Clobber if it doesn't exist.
             if (typeof parent[key] === 'undefined') {
             assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
             } else if (typeof obj.path !== 'undefined') {
             // If merging, merge properties onto parent, otherwise, clobber.
             if (merge) {
             recursiveMerge(parent[key], result);
             } else {
             assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
             }
             }
             result = parent[key];
             } else {
             // Overwrite if not currently defined.
             if (typeof parent[key] == 'undefined') {
             assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
             } else {
             // Set result to what already exists, so we can build children into it if they exist.
             result = parent[key];
             }
             }
             
             if (obj.children) {
             include(result, obj.children, clobber, merge);
             }
             } catch(e) {
             utils.alert('Exception building x1bridge JS globals: ' + e + ' for key "' + key + '"');
             }
             });
        }
        
/**
 * Merge properties from one object onto another recursively.  Properties from
 * the src object will overwrite existing target property.
 *
 * @param target Object to merge properties into.
 * @param src Object to merge properties from.
 */
        function recursiveMerge(target, src) {
        for (var prop in src) {
        if (src.hasOwnProperty(prop)) {
        if (target.prototype && target.prototype.constructor === target) {
        // If the target object is a constructor override off prototype.
        clobber(target.prototype, prop, src[prop]);
        } else {
        if (typeof src[prop] === 'object' && typeof target[prop] === 'object') {
        recursiveMerge(target[prop], src[prop]);
        } else {
        clobber(target, prop, src[prop]);
        }
        }
        }
        }
        }
        
        exports.buildIntoButDoNotClobber = function(objects, target) {
        include(target, objects, false, false);
        };
        exports.buildIntoAndClobber = function(objects, target) {
        include(target, objects, true, false);
        };
        exports.buildIntoAndMerge = function(objects, target) {
        include(target, objects, true, true);
        };
        exports.recursiveMerge = recursiveMerge;
        exports.assignOrWrapInDeprecateGetter = assignOrWrapInDeprecateGetter;
        exports.replaceHookForTesting = function() {};
        
        });
 
 
	// file: lib/common/channel.js
	define("x1bridge/channel", function(require, exports, module) {

		var utils = require('x1bridge/utils'),
			nextGuid = 1;

		var Channel = function(type, sticky) {
			this.type = type;
			// Map of guid -> function.
			this.handlers = {};
			// 0 = Non-sticky, 1 = Sticky non-fired, 2 = Sticky fired.
			this.state = sticky ? 1 : 0;
			// Used in sticky mode to remember args passed to fire().
			this.fireArgs = null;
			// Used by onHasSubscribersChange to know if there are any listeners.
			this.numHandlers = 0;
			// Function that is called when the first listener is subscribed, or when
			// the last listener is unsubscribed.
			this.onHasSubscribersChange = null;
		},
			channel = {
				/**
				 * Calls the provided function only after all of the channels specified
				 * have been fired. All channels must be sticky channels.
				 */
				join: function(h, c) {
					var len = c.length,
						i = len,
						f = function() {
							if (!(--i)) h();
						};
					for (var j = 0; j < len; j++) {
						if (c[j].state === 0) {
							throw Error('Can only use join with sticky channels.');
						}
						c[j].subscribe(f);
					}
					if (!len) h();
				},
				create: function(type) {
					return channel[type] = new Channel(type, false);
				},
				createSticky: function(type) {
					return channel[type] = new Channel(type, true);
				},

				/**
				 * x1bridge Channels that must fire before "deviceready" is fired.
				 */
				deviceReadyChannelsArray: [],
				deviceReadyChannelsMap: {},

				/**
				 * Indicate that a feature needs to be initialized before it is ready to be used.
				 * This holds up X1bridge's "deviceready" event until the feature has been initialized
				 * and X1bridge.initComplete(feature) is called.
				 *
				 * @param feature {String}     The unique feature name
				 */
				waitForInitialization: function(feature) {
					if (feature) {
						var c = channel[feature] || this.createSticky(feature);
						this.deviceReadyChannelsMap[feature] = c;
						this.deviceReadyChannelsArray.push(c);
					}
				},

				/**
				 * Indicate that initialization code has completed and the feature is ready to be used.
				 *
				 * @param feature {String}     The unique feature name
				 */
				initializationComplete: function(feature) {
					var c = this.deviceReadyChannelsMap[feature];
					if (c) {
						c.fire();
					}
				}
			};

		function forceFunction(f) {
			if (typeof f != 'function') throw "Function required as first argument!";
		}

		/**
		 * Subscribes the given function to the channel. Any time that
		 * Channel.fire is called so too will the function.
		 * Optionally specify an execution context for the function
		 * and a guid that can be used to stop subscribing to the channel.
		 * Returns the guid.
		 */
		Channel.prototype.subscribe = function(f, c) {
			// need a function to call
			forceFunction(f);
			if (this.state == 2) {
				f.apply(c || this, this.fireArgs);
				return;
			}

			var func = f,
				guid = f.observer_guid;
			if (typeof c == "object") {
				func = utils.close(c, f);
			}

			if (!guid) {
				// first time any channel has seen this subscriber
				guid = '' + nextGuid++;
			}
			func.observer_guid = guid;
			f.observer_guid = guid;

			// Don't add the same handler more than once.
			if (!this.handlers[guid]) {
				this.handlers[guid] = func;
				this.numHandlers++;
				if (this.numHandlers == 1) {
					this.onHasSubscribersChange && this.onHasSubscribersChange();
				}
			}
		};

		/**
		 * Unsubscribes the function with the given guid from the channel.
		 */
		Channel.prototype.unsubscribe = function(f) {
			// need a function to unsubscribe
			forceFunction(f);

			var guid = f.observer_guid,
				handler = this.handlers[guid];
			if (handler) {
				delete this.handlers[guid];
				this.numHandlers--;
				if (this.numHandlers === 0) {
					this.onHasSubscribersChange && this.onHasSubscribersChange();
				}
			}
		};

		/**
		 * Calls all functions subscribed to this channel.
		 */
		Channel.prototype.fire = function(e) {
			var fail = false,
				fireArgs = Array.prototype.slice.call(arguments);
			// Apply stickiness.
			if (this.state == 1) {
				this.state = 2;
				this.fireArgs = fireArgs;
			}
			if (this.numHandlers) {
				// Copy the values first so that it is safe to modify it from within
				// callbacks.
				var toCall = [];
				for (var item in this.handlers) {
					toCall.push(this.handlers[item]);
				}
				for (var i = 0; i < toCall.length; ++i) {
					toCall[i].apply(this, fireArgs);
				}
				if (this.state == 2 && this.numHandlers) {
					this.numHandlers = 0;
					this.handlers = {};
					this.onHasSubscribersChange && this.onHasSubscribersChange();
				}
			}
		};
           // defining them here so they are ready super fast!
           // DOM event that is received when the web page is loaded and parsed.
           channel.createSticky('onDOMContentLoaded');
           
           // Event to indicate the X1bridge native side is ready.
           channel.createSticky('onNativeReady');
           
           // Event to indicate that all X1bridge JavaScript objects have been created
           // and it's time to run plugin constructors.
           channel.createSticky('onX1bridgeReady');
           
           // Event to indicate that device properties are available
           channel.createSticky('onX1bridgeInfoReady');
           
           // Event to indicate that the connection property has been set.
           channel.createSticky('onX1bridgeConnectionReady');
           
           // Event to indicate that all automatically loaded JS plugins are loaded and ready.
           channel.createSticky('onPluginsReady');
           
           // Event to indicate that X1bridge is ready
           channel.createSticky('onDeviceReady');
           
           // Event to indicate a resume lifecycle event
           channel.create('onResume');
           
           // Event to indicate a pause lifecycle event
           channel.create('onPause');
           
           // Event to indicate a destroy lifecycle event
           channel.createSticky('onDestroy');
           
		// Channels that must fire before "deviceready" is fired.
		channel.waitForInitialization('onX1bridgeReady');
		channel.waitForInitialization('onX1bridgeConnectionReady');
		channel.waitForInitialization('onDOMContentLoaded');

		module.exports = channel;

	});

	// file: lib/ios/exec.js
	define("x1bridge/exec", function(require, exports, module) {
		/**
		 * Creates a gap bridge iframe used to notify the native code about queued
		 * commands.
		 *
		 * @private
		 */
		var x1bridge = require('x1bridge'),
			channel = require('x1bridge/channel'),
			utils = require('x1bridge/utils'),
			jsToNativeModes = {
				IFRAME_NAV: 0,
				XHR_NO_PAYLOAD: 1,
				XHR_WITH_PAYLOAD: 2,
				XHR_OPTIONAL_PAYLOAD: 3
			},
			bridgeMode,
			execIframe,
			execXhr,
			requestCount = 0,
			vcHeaderValue = null,
			commandQueue = [], // Contains pending JS->Native messages.
			isInContextOfEvalJs = 0;

		function createExecIframe() {
			var iframe = document.createElement("iframe");
			iframe.style.display = 'none';
			document.body.appendChild(iframe);
			return iframe;
		}

		function shouldBundleCommandJson() {
			if (bridgeMode == jsToNativeModes.XHR_WITH_PAYLOAD) {
				return true;
			}
			if (bridgeMode == jsToNativeModes.XHR_OPTIONAL_PAYLOAD) {
				var payloadLength = 0;
				for (var i = 0; i < commandQueue.length; ++i) {
					payloadLength += commandQueue[i].length;
				}
				// The value here was determined using the benchmark within X1bridgeLibApp on an iPad 3.
				return payloadLength < 4500;
			}
			return false;
		}

		function massageArgsJsToNative(args) {
			if (!args || utils.typeName(args) != 'Array') {
				return args;
			}
			var ret = [];
			var encodeArrayBufferAs8bitString = function(ab) {
				return String.fromCharCode.apply(null, new Uint8Array(ab));
			};
			var encodeArrayBufferAsBase64 = function(ab) {
				return window.btoa(encodeArrayBufferAs8bitString(ab));
			};
			args.forEach(function(arg, i) {
				if (utils.typeName(arg) == 'ArrayBuffer') {
					ret.push({
						'CDVType': 'ArrayBuffer',
						'data': encodeArrayBufferAsBase64(arg)
					});
				} else {
					ret.push(arg);
				}
			});
			return ret;
		}

		function massageMessageNativeToJs(message) {
			if (message.CDVType == 'ArrayBuffer') {
				var stringToArrayBuffer = function(str) {
					var ret = new Uint8Array(str.length);
					for (var i = 0; i < str.length; i++) {
						ret[i] = str.charCodeAt(i);
					}
					return ret.buffer;
				};
				var base64ToArrayBuffer = function(b64) {
					return stringToArrayBuffer(atob(b64));
				};
				message = base64ToArrayBuffer(message.data);
			}
			return message;
		}

		function convertMessageToArgsNativeToJs(message) {
			var args = [];
			if (!message || !message.hasOwnProperty('CDVType')) {
				args.push(message);
			} else if (message.CDVType == 'MultiPart') {
				message.messages.forEach(function(e) {
					args.push(massageMessageNativeToJs(e));
				});
			} else {
				args.push(massageMessageNativeToJs(message));
			}
			return args;
		}

		function iOSExec() {
			// XHR mode does not work on iOS 4.2, so default to IFRAME_NAV for such devices.
			// XHR mode's main advantage is working around a bug in -webkit-scroll, which
			// doesn't exist in 4.X devices anyways.
			if (bridgeMode === undefined) {
				bridgeMode = navigator.userAgent.indexOf(' 4_') == -1 ? jsToNativeModes.XHR_NO_PAYLOAD : jsToNativeModes.IFRAME_NAV;
			}

			var successCallback, failCallback, service, action, actionArgs, splitCommand;
			var callbackId = 0;
			// if (typeof arguments[0] !== "string") {
				// FORMAT ONE
				successCallback = arguments[2];
				failCallback = arguments[3];
				// service = arguments[2];
				action = arguments[0];
				actionArgs = arguments[1];

				// Since we need to maintain backwards compatibility, we have to pass
				// an invalid callbackId even if no callback was provided since plugins
				// will be expecting it. The X1bridge.exec() implementation allocates
				// an invalid callbackId and passes it even if no callbacks were given.
				//callbackId = 'INVALID';
			// } else {
			// 	// FORMAT TWO, REMOVED
			// 	try {
			// 		splitCommand = arguments[0].split(".");
			// 		action = splitCommand.pop();
			// 		service = splitCommand.join(".");
			// 		actionArgs = Array.prototype.splice.call(arguments, 1);

			// 		console.log('The old format of this exec call has been removed (deprecated since 2.1). Change to: ' +
			// 			"x1bridge.exec(null, null, \"" + service + "\", \"" + action + "\"," + JSON.stringify(actionArgs) + ");"
			// 		);
			// 		return;
			// 	} catch (e) {}
			// }

			// Register the callbacks and add the callbackId to the positional
			// arguments if given.
			if (successCallback || failCallback) {
				callbackId = action + x1bridge.callbackId++;
				x1bridge.callbacks[callbackId] = {
					success: successCallback,
					fail: failCallback
				};
			}else{
				callbackId = 'INVALID';
			}

			actionArgs = massageArgsJsToNative(actionArgs);

			var command = [callbackId, action, actionArgs, ];

			//       alert(action );
			//       alert(actionArgs);
			//       alert(command);
			// Stringify and queue the command. We stringify to command now to
			// effectively clone the command arguments in case they are mutated before
			// the command is executed.
			commandQueue.push(JSON.stringify(command));

			// If we're in the context of a stringByEvaluatingJavaScriptFromString call,
			// then the queue will be flushed when it returns; no need for a poke.
			// Also, if there is already a command in the queue, then we've already
			// poked the native side, so there is no reason to do so again.
			if (!isInContextOfEvalJs && commandQueue.length == 1) {
				if (bridgeMode == jsToNativeModes.IFRAME_NAV) {
					// This prevents sending an XHR when there is already one being sent.
					// This should happen only in rare circumstances (refer to unit tests).
					if (execXhr && execXhr.readyState != 4) {
						execXhr = null;
					}
					// Re-using the XHR improves exec() performance by about 10%.
					execXhr = execXhr || new XMLHttpRequest();
					// Changing this to a GET will make the XHR reach the URIProtocol on 4.2.
					// For some reason it still doesn't work though...
					// Add a timestamp to the query param to prevent caching.
					execXhr.open('HEAD', "/!x1bridge_exec?" + (+new Date()), true);
					if (!vcHeaderValue) {
						vcHeaderValue = /.*\((.*)\)/.exec(navigator.userAgent)[1];
					}
					execXhr.setRequestHeader('vc', vcHeaderValue);
					execXhr.setRequestHeader('rc', ++requestCount);
					if (shouldBundleCommandJson()) {
						execXhr.setRequestHeader('cmds', iOSExec.nativeFetchMessages());
					}
					execXhr.send(null);
				} else {
					execIframe = execIframe || createExecIframe();
					execIframe.src = "x1bridge://ready";
				}
			}
		}

		iOSExec.jsToNativeModes = jsToNativeModes;

		iOSExec.setJsToNativeBridgeMode = function(mode) {
			// Remove the iFrame since it may be no longer required, and its existence
			// can trigger browser bugs.
			// https://issues.apache.org/jira/browse/CB-593
			if (execIframe) {
				execIframe.parentNode.removeChild(execIframe);
				execIframe = null;
			}
			bridgeMode = mode;
		};

		iOSExec.nativeFetchMessages = function() {
			// Each entry in commandQueue is a JSON string already.
			if (!commandQueue.length) {
//           alert("empty commandQueue");
				return '';
			}
//           alert(commandQueue);
			var json = '[' + commandQueue.join(',') + ']';
			commandQueue.length = 0;
			return json;
		};

		iOSExec.nativeCallback = function(callbackId, status, message, keepCallback) {
//           alert("native callback");
			return iOSExec.nativeEvalAndFetch(function() {
//                alert("status" + status);
				var success = status == 0;
//                alert("success" + success);
				var args = convertMessageToArgsNativeToJs(message);
				x1bridge.callbackFromNative(callbackId, success, status, args, keepCallback);
			});
		};

		iOSExec.nativeEvalAndFetch = function(func) {
			// This shouldn't be nested, but better to be safe.
			isInContextOfEvalJs++;
			try {
				func();
//                alert("callback end and fetch another message");
				return iOSExec.nativeFetchMessages();
			} finally {
				isInContextOfEvalJs--;
			}
		};

		module.exports = iOSExec;
	});

	// file: lib/common/modulemapper.js
	define("x1bridge/modulemapper", function(require, exports, module) {

		var builder = require('x1bridge/builder'),
			moduleMap = define.moduleMap,
			symbolList,
			deprecationMap;

		exports.reset = function() {
			symbolList = [];
			deprecationMap = {};
		};

		function addEntry(strategy, moduleName, symbolPath, opt_deprecationMessage) {
			if (!(moduleName in moduleMap)) {
				throw new Error('Module ' + moduleName + ' does not exist.');
			}
			symbolList.push(strategy, moduleName, symbolPath);
			if (opt_deprecationMessage) {
				deprecationMap[symbolPath] = opt_deprecationMessage;
			}
		}

		// Note: Android 2.3 does have Function.bind().
		exports.clobbers = function(moduleName, symbolPath, opt_deprecationMessage) {
			addEntry('c', moduleName, symbolPath, opt_deprecationMessage);
		};

		exports.merges = function(moduleName, symbolPath, opt_deprecationMessage) {
			addEntry('m', moduleName, symbolPath, opt_deprecationMessage);
		};

		exports.defaults = function(moduleName, symbolPath, opt_deprecationMessage) {
			addEntry('d', moduleName, symbolPath, opt_deprecationMessage);
		};

		function prepareNamespace(symbolPath, context) {
			if (!symbolPath) {
				return context;
			}
			var parts = symbolPath.split('.');
			var cur = context;
			for (var i = 0, part; part = parts[i]; ++i) {
				cur = cur[part] = cur[part] || {};
			}
			return cur;
		}

		exports.mapModules = function(context) {
			var origSymbols = {};
			context.CDV_origSymbols = origSymbols;
			for (var i = 0, len = symbolList.length; i < len; i += 3) {
				var strategy = symbolList[i];
				var moduleName = symbolList[i + 1];
				var symbolPath = symbolList[i + 2];
				var lastDot = symbolPath.lastIndexOf('.');
				var namespace = symbolPath.substr(0, lastDot);
				var lastName = symbolPath.substr(lastDot + 1);

				var module = require(moduleName);
				var deprecationMsg = symbolPath in deprecationMap ? 'Access made to deprecated symbol: ' + symbolPath + '. ' + deprecationMsg : null;
				var parentObj = prepareNamespace(namespace, context);
				var target = parentObj[lastName];

				if (strategy == 'm' && target) {
					builder.recursiveMerge(target, module);
				} else if ((strategy == 'd' && !target) || (strategy != 'd')) {
					if (!(symbolPath in origSymbols)) {
						origSymbols[symbolPath] = target;
					}
					builder.assignOrWrapInDeprecateGetter(parentObj, lastName, module, deprecationMsg);
				}
			}
		};

		exports.getOriginalSymbol = function(context, symbolPath) {
			var origSymbols = context.CDV_origSymbols;
			if (origSymbols && (symbolPath in origSymbols)) {
				return origSymbols[symbolPath];
			}
			var parts = symbolPath.split('.');
			var obj = context;
			for (var i = 0; i < parts.length; ++i) {
				obj = obj && obj[parts[i]];
			}
			return obj;
		};

		exports.loadMatchingModules = function(matchingRegExp) {
			for (var k in moduleMap) {
				if (matchingRegExp.exec(k)) {
					require(k);
				}
			}
		};

		exports.reset();


	});

	// file: lib/ios/platform.js
	define("x1bridge/platform", function(require, exports, module) {

		module.exports = {
			id: "ios",
			initialize: function() {
				var modulemapper = require('x1bridge/modulemapper');

				modulemapper.loadMatchingModules(/x1bridge.*\/plugininit$/);

				modulemapper.loadMatchingModules(/x1bridge.*\/symbols$/);
				modulemapper.mapModules(window);
			}
		};


	});

	// file: lib/common/symbols.js
	define("x1bridge/symbols", function(require, exports, module) {
		var modulemapper = require('x1bridge/modulemapper');

		// Use merges here in case others symbols files depend on this running first,
		// but fail to declare the dependency with a require().
		modulemapper.merges('x1bridge', 'x1bridge');
		modulemapper.clobbers('x1bridge/exec', 'x1bridge.exec');
		modulemapper.clobbers('x1bridge/exec', 'X1bridge.exec');
	});

	// file: lib/common/utils.js
	define("x1bridge/utils", function(require, exports, module) {

		var utils = exports;

		/**
		 * Defines a property getter / setter for obj[key].
		 */
		utils.defineGetterSetter = function(obj, key, getFunc, opt_setFunc) {
			if (Object.defineProperty) {
				var desc = {
					get: getFunc,
					configurable: true
				};
				if (opt_setFunc) {
					desc.set = opt_setFunc;
				}
				Object.defineProperty(obj, key, desc);
			} else {
				obj.__defineGetter__(key, getFunc);
				if (opt_setFunc) {
					obj.__defineSetter__(key, opt_setFunc);
				}
			}
		};

		/**
		 * Defines a property getter for obj[key].
		 */
		utils.defineGetter = utils.defineGetterSetter;

		utils.arrayIndexOf = function(a, item) {
			if (a.indexOf) {
				return a.indexOf(item);
			}
			var len = a.length;
			for (var i = 0; i < len; ++i) {
				if (a[i] == item) {
					return i;
				}
			}
			return -1;
		};

		/**
		 * Returns whether the item was found in the array.
		 */
		utils.arrayRemove = function(a, item) {
			var index = utils.arrayIndexOf(a, item);
			if (index != -1) {
				a.splice(index, 1);
			}
			return index != -1;
		};

		utils.typeName = function(val) {
			return Object.prototype.toString.call(val).slice(8, -1);
		};

		/**
		 * Returns an indication of whether the argument is an array or not
		 */
		utils.isArray = function(a) {
			return utils.typeName(a) == 'Array';
		};

		/**
		 * Returns an indication of whether the argument is a Date or not
		 */
		utils.isDate = function(d) {
			return utils.typeName(d) == 'Date';
		};

		/**
		 * Does a deep clone of the object.
		 */
		utils.clone = function(obj) {
			if (!obj || typeof obj == 'function' || utils.isDate(obj) || typeof obj != 'object') {
				return obj;
			}

			var retVal, i;

			if (utils.isArray(obj)) {
				retVal = [];
				for (i = 0; i < obj.length; ++i) {
					retVal.push(utils.clone(obj[i]));
				}
				return retVal;
			}

			retVal = {};
			for (i in obj) {
				if (!(i in retVal) || retVal[i] != obj[i]) {
					retVal[i] = utils.clone(obj[i]);
				}
			}
			return retVal;
		};

		/**
		 * Returns a wrapped version of the function
		 */
		utils.close = function(context, func, params) {
			if (typeof params == 'undefined') {
				return function() {
					return func.apply(context, arguments);
				};
			} else {
				return function() {
					return func.apply(context, params);
				};
			}
		};

		/**
		 * Extends a child object from a parent object using classical inheritance
		 * pattern.
		 */
		utils.extend = (function() {
			// proxy used to establish prototype chain
			var F = function() {};
			// extend Child from Parent
			return function(Child, Parent) {
				F.prototype = Parent.prototype;
				Child.prototype = new F();
				Child.__super__ = Parent.prototype;
				Child.prototype.constructor = Child;
			};
		}());

		/**
		 * Alerts a message in any available way: alert or console.log.
		 */
		utils.alert = function(msg) {
			if (window.alert) {
				window.alert(msg);
			} else if (console && console.log) {
				console.log(msg);
			}
		};
	});

	window.x1bridge = require('x1bridge');
	// file: lib/scripts/bootstrap.js
 
    document.addEventListener('DOMContentLoaded',function() {
       var iframe = document.createElement("iframe");
       iframe.style.display = 'none';
       document.body.appendChild(iframe);
       iframe.src = "x1bridge://onDOMLoaded";
    });

	(function(context) {
		if (context._x1bridgeJsLoaded) {
			throw new Error('x1bridge.js included multiple times.');
		}
		context._x1bridgeJsLoaded = true;

		var channel = require('x1bridge/channel');
		var platformInitChannelsArray = [channel.onNativeReady, channel.onPluginsReady];

		function logUnfiredChannels(arr) {
			for (var i = 0; i < arr.length; ++i) {
				if (arr[i].state != 2) {
					console.log('Channel not fired: ' + arr[i].type);
				}
			}
		}

		window.setTimeout(function() {
			if (channel.onDeviceReady.state != 2) {
				console.log('deviceready has not fired after 5 seconds.');
				logUnfiredChannels(platformInitChannelsArray);
				logUnfiredChannels(channel.deviceReadyChannelsArray);
			}
		}, 5000);

		// Replace navigator before any modules are required(), to ensure it happens as soon as possible.
		// We replace it so that properties that can't be clobbered can instead be overridden.

		function replaceNavigator(origNavigator) {
			var X1bridgeNavigator = function() {};
			X1bridgeNavigator.prototype = origNavigator;
			var newNavigator = new X1bridgeNavigator();
			// This work-around really only applies to new APIs that are newer than Function.bind.
			// Without it, APIs such as getGamepads() break.
			if (X1bridgeNavigator.bind) {
				for (var key in origNavigator) {
					if (typeof origNavigator[key] == 'function') {
						newNavigator[key] = origNavigator[key].bind(origNavigator);
					}
				}
			}
			return newNavigator;
		}
		if (context.navigator) {
			context.navigator = replaceNavigator(context.navigator);
		}

		// _nativeReady is global variable that the native side can set
		// to signify that the native code is ready. It is a global since
		// it may be called before any x1bridge JS is ready.
		if (window._nativeReady) {
			channel.onNativeReady.fire();
		}

		/**
		 * Create all x1bridge objects once native side is ready.
		 */
		channel.join(function() {
			// Call the platform-specific initialization
			require('x1bridge/platform').initialize();

			// Fire event to notify that all objects are created
			channel.onX1bridgeReady.fire();

			// Fire onDeviceReady event once page has fully loaded, all
			// constructors have run and x1bridge info has been received from native
			// side.
			// This join call is deliberately made after platform.initialize() in
			// order that plugins may manipulate channel.deviceReadyChannelsArray
			// if necessary.
			channel.join(function() {
				require('x1bridge').fireDocumentEvent('deviceready');
			}, channel.deviceReadyChannelsArray);
		}, platformInitChannelsArray);

	}(window));
	// file: lib/scripts/bootstrap-ios.js

	require('x1bridge/channel').onNativeReady.fire();
 
	// file: lib/scripts/plugin_loader.js

	// Tries to load all plugins' js-modules.
	// This is an async process, but onDeviceReady is blocked on onPluginsReady.
	// onPluginsReady is fired when there are no plugins to load, or they are all done.
	(function(context) {
		// To be populated with the handler by handlePluginsObject.
		var onScriptLoadingComplete;

		var scriptCounter = 0;

		function scriptLoadedCallback() {
			scriptCounter--;
			if (scriptCounter === 0) {
				onScriptLoadingComplete && onScriptLoadingComplete();
			}
		}

		function scriptErrorCallback(err) {
			// Open Question: If a script path specified in x1bridge_plugins.js does not exist, do we fail for all?
			// this is currently just continuing.
			scriptCounter--;
			if (scriptCounter === 0) {
				onScriptLoadingComplete && onScriptLoadingComplete();
			}
		}

		// Helper function to inject a <script> tag.

		function injectScript(path) {
			scriptCounter++;
			var script = document.createElement("script");
			script.onload = scriptLoadedCallback;
			script.onerror = scriptErrorCallback;
			script.src = path;
			document.head.appendChild(script);
		}

		// Called when:
		// * There are plugins defined and all plugins are finished loading.
		// * There are no plugins to load.

		function finishPluginLoading() {
			context.x1bridge.require('x1bridge/channel').onPluginsReady.fire();
		}

		// Handler for the x1bridge_plugins.js content.
		// See plugman's plugin_loader.js for the details of this object.
		// This function is only called if the really is a plugins array that isn't empty.
		// Otherwise the onerror response handler will just call finishPluginLoading().

		// Find the root of the app
		var path = '';
		var scripts = document.getElementsByTagName('script');
		var term = 'x1bridge.js';
		for (var n = scripts.length - 1; n > -1; n--) {
			var src = scripts[n].src;
			if (src.indexOf(term) == (src.length - term.length)) {
				path = src.substring(0, src.length - term.length);
				break;
			}
		}

		var plugins_json = path + 'x1bridge_plugins.json';
		var plugins_js = path + 'x1bridge_plugins.js';

		// One some phones (Windows) this xhr.open throws an Access Denied exception
		// So lets keep trying, but with a script tag injection technique instead of XHR
		var injectPluginScript = function injectPluginScript() {
			try {
				var script = document.createElement("script");
				script.onload = function() {
					var list = x1bridge.require("x1bridge/plugin_list");
					handlePluginsObject(list, path);
				};
				script.onerror = function() {
					// Error loading x1bridge_plugins.js, file not found or something
					// this is an acceptable error, pre-3.0.0, so we just move on.
					finishPluginLoading();
				};
				script.src = plugins_js;
				document.head.appendChild(script);

			} catch (err) {
				finishPluginLoading();
			}
		}


		// Try to XHR the x1bridge_plugins.json file asynchronously.
		var xhr = new XMLHttpRequest();
		xhr.onload = function() {
			// If the response is a JSON string which composes an array, call handlePluginsObject.
			// If the request fails, or the response is not a JSON array, just call finishPluginLoading.
			var obj;
			try {
				obj = (this.status == 0 || this.status == 200) && this.responseText && JSON.parse(this.responseText);
			} catch (err) {
				// obj will be undefined.
			}
			if (Array.isArray(obj) && obj.length > 0) {
				handlePluginsObject(obj, path);
			} else {
				finishPluginLoading();
			}
		};
		xhr.onerror = function() {
			// In this case, the json file was not present, but XHR was allowed, 
			// so we should still try the script injection technique with the js file
			// in case that is there.
			injectPluginScript();
		};
		try { // we commented we were going to try, so let us actually try and catch
			xhr.open('GET', plugins_json, true); // Async
			xhr.send();
		} catch (err) {
			injectPluginScript();
		}
	}(window));
 })();var nouse = x1bridge;

